Course: Python Training
Topic: Implementing Inheritance and Its Types
Course Link: Python Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy
Inheritance is one of the fundamental concepts of object-oriented programming (OOP). It allows a class to acquire attributes and methods from another class. Instead of writing the same code repeatedly, developers can create a parent class containing common functionality and child classes that reuse or extend it.
Python supports inheritance through class definitions. A child class can use inherited methods, introduce new methods, override existing methods, and extend initialization behavior.
| Term | Meaning |
|---|---|
| Parent class | The class whose attributes and methods can be inherited by another class. |
| Child class | The class that inherits from another class. |
| Base class | Another name for a parent class. |
| Derived class | Another name for a child class. |
| Method overriding | Defining a method in a child class with the same name as an inherited method to provide different behavior. |
| super() | A built-in function commonly used to access methods from the next class in the method resolution order. |
In Python, a child class specifies its parent class inside parentheses after the class name.
class Parent:
def parent_method(self):
print("This method belongs to the parent class")
class Child(Parent):
def child_method(self):
print("This method belongs to the child class")
obj = Child()
obj.parent_method()
obj.child_method()Output:
This method belongs to the parent class
This method belongs to the child classExplanation:
Parent class defines a method named parent_method().Child class inherits from Parent.Child can call both its own method and the inherited method.Inheritance is commonly classified into five types: single, multiple, multilevel, hierarchical, and hybrid inheritance.
| Type | Description | Example relationship |
|---|---|---|
| Single inheritance | One child class inherits from one parent class. | Animal → Dog |
| Multiple inheritance | One child class inherits from two or more parent classes. | Camera + Phone → SmartPhone |
| Multilevel inheritance | A class inherits from a child class, creating a chain. | Animal → Mammal → Dog |
| Hierarchical inheritance | Multiple child classes inherit from one parent class. | Animal → Dog and Cat |
| Hybrid inheritance | A combination of two or more inheritance patterns. | Multiple and multilevel inheritance combined |
Single inheritance occurs when one child class inherits from one parent class. It is the simplest and most common form of inheritance.
class Animal:
def eat(self):
print("Animals can eat")
class Dog(Animal):
def bark(self):
print("Dog barks")
dog = Dog()
dog.eat()
dog.bark()Output:
Animals can eat
Dog barksExplanation: The Dog class inherits the eat() method from Animal and defines its own bark() method.
Multiple inheritance occurs when a child class inherits from more than one parent class. Python supports this directly.
class Camera:
def take_photo(self):
print("Taking a photo")
class Phone:
def make_call(self):
print("Making a phone call")
class SmartPhone(Camera, Phone):
def browse_internet(self):
print("Browsing the internet")
mobile = SmartPhone()
mobile.take_photo()
mobile.make_call()
mobile.browse_internet()Output:
Taking a photo
Making a phone call
Browsing the internetExplanation: The SmartPhone class inherits methods from both Camera and Phone. It also introduces its own functionality.
Multilevel inheritance occurs when one class inherits from another child class, creating a chain of inheritance. A class at the bottom of the chain can access eligible inherited functionality from classes higher in the hierarchy.
class Animal:
def eat(self):
print("Animal eats food")
class Mammal(Animal):
def walk(self):
print("Mammals can walk")
class Dog(Mammal):
def bark(self):
print("Dog barks")
dog = Dog()
dog.eat()
dog.walk()
dog.bark()Output:
Animal eats food
Mammals can walk
Dog barksExplanation:
Animal defines the eat() method.Mammal inherits from Animal and defines walk().Dog inherits from Mammal and defines bark().Dog instance can access methods from all three levels.Hierarchical inheritance occurs when multiple child classes inherit from the same parent class. Each child can reuse the parent's functionality while implementing its own specialized behavior.
class Animal:
def eat(self):
print("Animal eats food")
class Dog(Animal):
def bark(self):
print("Dog barks")
class Cat(Animal):
def meow(self):
print("Cat meows")
dog = Dog()
cat = Cat()
dog.eat()
dog.bark()
cat.eat()
cat.meow()Output:
Animal eats food
Dog barks
Animal eats food
Cat meowsExplanation: Both Dog and Cat inherit eat() from Animal, but each child class has its own specific method.
Hybrid inheritance combines two or more inheritance patterns. For example, a class hierarchy may contain both multilevel and multiple inheritance.
class Person:
def introduce(self):
print("I am a person")
class Student(Person):
def study(self):
print("I study")
class Employee(Person):
def work(self):
print("I work")
class WorkingStudent(Student, Employee):
def manage_time(self):
print("I balance work and study")
person = WorkingStudent()
person.introduce()
person.study()
person.work()
person.manage_time()Output:
I am a person
I study
I work
I balance work and studyExplanation:
Student and Employee both inherit from Person.WorkingStudent inherits from both Student and Employee.Person, so Python's method resolution order determines how inherited methods are looked up.Method overriding occurs when a child class defines a method with the same name as a method inherited from its parent class. When the method is called on the child instance, Python generally uses the child's implementation.
class Animal:
def sound(self):
print("Animal makes a sound")
class Dog(Animal):
def sound(self):
print("Dog barks")
animal = Animal()
dog = Dog()
animal.sound()
dog.sound()Output:
Animal makes a sound
Dog barksExplanation: The Dog class overrides the inherited sound() method. The same method name produces different behavior depending on the object.
The super() function provides access to methods from the next class in the method resolution order (MRO). It is commonly used to call a parent initializer or extend an inherited method.
class Person:
def __init__(self, name):
self.name = name
def display(self):
print("Name:", self.name)
class Student(Person):
def __init__(self, name, course):
super().__init__(name)
self.course = course
def display_course(self):
print("Course:", self.course)
student = Student("Amit", "Python")
student.display()
student.display_course()Output:
Name: Amit
Course: PythonExplanation:
Person initializer sets the name attribute.Student initializer calls super().__init__(name) to reuse that initialization logic.course attribute.In multiple inheritance, super() follows the method resolution order rather than always meaning a direct call to one specific parent. Cooperative inheritance works best when participating classes use compatible method signatures and call super() consistently.
The method resolution order determines the order in which Python searches classes for a method or attribute. It is especially important when multiple inheritance is involved.
class A:
def show(self):
print("Class A")
class B(A):
def show(self):
print("Class B")
class C(A):
def show(self):
print("Class C")
class D(B, C):
pass
obj = D()
obj.show()
print(D.mro())Output for the method call:
Class BThe method lookup starts with D, then follows its MRO, which in this case includes B, C, A, and object. Since B defines show(), Python uses that implementation.
Use ClassName.mro() to inspect the lookup order when debugging inheritance behavior.
When a child class defines its own __init__(), it does not automatically execute the parent's custom initializer unless it calls it explicitly or otherwise arranges for that initialization. The super() function is a common way to reuse parent initialization.
class Parent:
def __init__(self):
self.message = "Initialized in Parent"
class Child(Parent):
def __init__(self):
self.child_message = "Initialized in Child"
obj = Child()
print(obj.child_message)
# print(obj.message) # Raises AttributeErrorOutput:
Initialized in ChildThe parent's custom initializer is not executed by the child initializer in this example, so message is not assigned to the instance.
class Parent:
def __init__(self):
self.message = "Initialized in Parent"
class Child(Parent):
def __init__(self):
super().__init__()
self.child_message = "Initialized in Child"
obj = Child()
print(obj.message)
print(obj.child_message)Output:
Initialized in Parent
Initialized in Child| Advantages | Disadvantages |
|---|---|
| Encourages code reuse. | Deep hierarchies can become difficult to understand. |
| Organizes related classes. | Changes in a parent class can affect child classes. |
| Supports method overriding and polymorphism. | Multiple inheritance can make method lookup more complex. |
| Allows specialized behavior to extend shared functionality. | Inappropriate inheritance creates tight coupling. |
| Can reduce duplicated implementation. | Some designs are clearer with composition instead. |
Inheritance represents an is-a relationship, while composition represents a has-a relationship. Choosing the correct relationship is important for maintainable object-oriented design.
| Feature | Inheritance | Composition |
|---|---|---|
| Relationship | Child is a specialized type of parent. | One object contains or uses another object. |
| Code reuse | Reuses inherited methods and attributes. | Reuses functionality through contained objects. |
| Coupling | Can create a strong dependency on the parent class. | Often allows components to be changed independently. |
| Example | Dog inherits from Animal. | Car has an Engine. |
class Engine:
def start(self):
print("Engine started")
class Car:
def __init__(self):
self.engine = Engine()
def start_car(self):
self.engine.start()
print("Car is ready")
car = Car()
car.start_car()Output:
Engine started
Car is readyThe Car class uses an Engine object rather than inheriting from the Engine class.
super() when extending parent initialization or behavior.| Problem | Possible Cause | Solution |
|---|---|---|
| AttributeError | A required parent initializer was not executed. | Call super().__init__() when appropriate. |
| TypeError during object creation | Required initializer arguments are missing or incorrect. | Check the initializer signature and arguments. |
| Unexpected method output | A child method overrides the parent method. | Inspect the class definitions and MRO. |
| Duplicate logic | Common behavior is repeatedly implemented in subclasses. | Move genuinely shared behavior into a suitable parent class. |
| Complex multiple inheritance | Parent classes define overlapping methods or incompatible initializers. | Review the MRO and use cooperative super() calls where appropriate. |
| Incorrect class relationship | Inheritance is used only to reuse unrelated functionality. | Consider composition or a standalone helper class. |
Create a Vehicle parent class with a method named start(). Create a Car child class with a method named drive(). Demonstrate both methods.
Create two classes, Camera and MusicPlayer. Define a SmartDevice class that inherits from both and provides an additional method.
Create a hierarchy consisting of Person, Employee, and Manager. Add a distinct method to each class and call all three from a manager object.
Create a parent class named Shape and child classes named Circle and Rectangle. Give both child classes their own area-calculation methods.
Create an Animal class with a sound() method. Override it in Dog and Cat to display different sounds.
Create a Person class that initializes a name and an Employee subclass that initializes a name and employee ID. Use super() to reuse the parent initializer.
Build an employee management program with a common Employee class and specialized subclasses such as Developer, Designer, and Manager. Store shared employee details in the parent class and implement role-specific methods in the child classes.
Answer: Inheritance is an OOP feature that allows a class to reuse and extend the attributes and methods of another class.
Answer: Single, multiple, multilevel, hierarchical, and hybrid inheritance.
Answer: Yes. A class can inherit from more than one parent class.
Answer: It is the process of defining a method in a child class with the same name as an inherited method to provide specialized behavior.
Answer: It provides access to methods in the next class in the method resolution order, commonly to reuse parent initialization or behavior.
Answer: It occurs when inheritance forms a chain, such as Animal, Mammal, and Dog.
Answer: It occurs when multiple child classes inherit from the same parent class.
Answer: It combines multiple inheritance patterns within a class hierarchy.
Answer: MRO determines the order in which Python searches classes for inherited methods and attributes.
Answer: Inheritance models an is-a relationship, while composition models a has-a relationship in which an object contains or uses another object.
super() follows the method resolution order.Inheritance is a powerful Python OOP feature that helps developers build reusable, organized, and extensible applications. Understanding single, multiple, multilevel, hierarchical, and hybrid inheritance makes it easier to model relationships between classes.
By practicing method overriding, constructor inheritance, super(), and method resolution order, you can develop a stronger understanding of how Python classes work together. Always choose inheritance relationships carefully and consider composition when it provides a simpler design.
Strengthen your Python programming skills with structured learning, hands-on examples, and object-oriented programming practice.
Python Training Course: Explore Python Training
Course Demo: Register for a Course Demo
JustAcademy Website: Visit JustAcademy
